package controller;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

import daohibernate.CotizacionDAO;
import daohibernate.PresupuestoDAO;
import daohibernate.ProveedorDAO;
import daohibernate.ServicioDAO;
import daohibernate.TipoEventoDAO;
import dto.CotizacionDTO;
import dto.PresupuestoDTO;
import dto.ProveedorDTO;
import dto.ServicioDTO;
import dto.TipoEventoDTO;
import entities.*;
import view.*;

public class Sistema {

	private Collection <Cotizacion> cotizaciones;
	public static Sistema instancia;
	private Collection <Empleado> empleados;
	private List<Presupuesto> presupuestos = new ArrayList<Presupuesto>();
	private List<Proveedor> proveedores = new ArrayList<Proveedor>();


	public static Sistema getInstancia(){
		if (instancia == null)
				instancia = new Sistema();
		return instancia;
	}
	
	
	//======================= CONSTRUCTOR =====================
	
		private Sistema() {
//			cargarColecciones();	
		}

	//==========================================================
	
	// SolicitudPresupuesto ------------------------------------------
	public void cargarSolicitudPresupuesto(PresupuestoDTO presupuesto)
	{
		PresupuestoDAO.getInstancia().grabarPresupuesto(DTOTransformer.toPresupuesto(presupuesto));
		presupuestos.add(DTOTransformer.toPresupuesto(presupuesto));
				
	}
	
	public void actualizarSolicitudPresupuesto(PresupuestoDTO presupuesto)
	{
		//realiza merge
		PresupuestoDAO.getInstancia().grabarPresupuesto(DTOTransformer.toPresupuesto(presupuesto));
		presupuestos.add(DTOTransformer.toPresupuesto(presupuesto));
				
	}
	
	// Presupuesto ------------------------------------------
	public List<PresupuestoDTO> consultarPresupuestos(String cuil, String estado, int idPresupuesto){
		List <PresupuestoDTO> presupuestos = new ArrayList<PresupuestoDTO>();
		List <PresupuestoDTO> presupuestosView = new ArrayList<PresupuestoDTO>();
		
		if(!cuil.equals(""))
			presupuestos = buscarPresupuestosPorCuil(cuil, estado);
		
		if(idPresupuesto != -1){
			if(presupuestos.size() == 0){
				PresupuestoDTO presup = buscarPresupuestosPorId(idPresupuesto, estado);
				if(presup != null)
					presupuestosView.add(presup);
			}else{
				for(PresupuestoDTO pres : presupuestos){
					if(pres.getIdPresupuesto() == idPresupuesto){
						presupuestosView.add(pres);
					}
				}
			}
		}

		/*
		Iterator<PresupuestoDTO> it = presupuestosView.iterator();
		List <PresupuestoDTO> presupView = new ArrayList<PresupuestoDTO>();
		
		while(it.hasNext())
		{
			PresupuestoDTO p = new PresupuestoDTO();
			presupView.add(it.next());
		}
		*/
		
		return presupuestosView;
	}
	
	//tiene que ir a buscar datos a la BD. (PresupuestoDAO)
	public List<PresupuestoDTO> buscarPresupuestosPorCuil(String cuil, String estado)
	{
		List <PresupuestoDTO> presupDTO = new ArrayList<PresupuestoDTO>();
		List <Presupuesto> presupues = new ArrayList<Presupuesto>();
		presupues = PresupuestoDAO.getInstancia().getPresupuestosPorCuil(cuil, estado);
		for (Presupuesto pres : presupues) presupDTO.add(DTOTransformer.toPresupuestoDTO(pres));
		return presupDTO;
	}
	
	//tiene que ir a buscar datos a la BD. (PresupuestoDAO)
		private PresupuestoDTO buscarPresupuestosPorId(int idPresupuesto, String estado)
		{
			PresupuestoDTO presupDTO = new PresupuestoDTO();
			Presupuesto presupues = new Presupuesto();
			presupues = PresupuestoDAO.getInstancia().ObtenerPresupuesto(idPresupuesto);
			
			if(presupues != null){
				presupDTO = DTOTransformer.toPresupuestoDTO(presupues);
				if(presupDTO.getEstado() == estado){
					return presupDTO;
				}
			}

			return null;
		}
	
	
	public PresupuestoDTO buscarPresupuesto(int idPresupuesto){
		return DTOTransformer.toPresupuestoDTO(PresupuestoDAO.getInstancia().ObtenerPresupuesto(idPresupuesto));
	}
	
	public void nuevoProveedor(ProveedorDTO proveedor)
	{
		ProveedorDAO.getInstancia().altaProveedor(DTOTransformer.toProveedor(proveedor));
		proveedores.add(DTOTransformer.toProveedor(proveedor));
				
	}
	
	
	// Cotizacion ------------------------------------------
	public void cargarCotizacion(Cotizacion cotizacion)	//int idCotizacion, String comentarios, String fechaCotizacion, String formaPagoProveedor, float precioCosto, float precioVenta, Proveedor proveedor, Servicio servicio)
	{
		cotizaciones.add(cotizacion);
	}
	
	public CotizacionDTO consultarCotizacionServicioPorProveedor(String cuit, int idServicio)
	{
		return DTOTransformer.toCotizacionDTO(CotizacionDAO.getInstancia().getCotizacionServicioPorProveedor(cuit, idServicio));
	}
	
	public Cotizacion buscarCotizacion(int idCotizacion)
	{
		Iterator<Cotizacion> it = cotizaciones.iterator();
		Cotizacion cotiz = new Cotizacion();
		boolean encontrado = false;
		
		while(it.hasNext() && !encontrado)
		{
			if(it.next().getIdCotizacion() == idCotizacion){
				cotiz = it.next();
				encontrado = true;
			}
		}	
		return cotiz;
	}
	
	

	// calcularRentabilidad ------------------------------------------
	public void calcularRentabilidad(int idPresupuesto){

	}

	
	// Servicio ------------------------------------------
	public List<ServicioDTO> consultarServicios()
	{
		List<ServicioDTO> serviciosDTO = null;
		List<Servicio> servicios = ServicioDAO.getInstancia().getServicios();
		if (servicios != null && !servicios.isEmpty())
		{
			serviciosDTO = new ArrayList<ServicioDTO>();
			for (Servicio servicio : servicios){
				ServicioDTO servicioDTO = DTOTransformer.toServicioDTO(servicio);
				serviciosDTO.add(servicioDTO);
			}
		}
		return serviciosDTO;
	}
	
	public ServicioDTO consultarServicioPorDescripcion(String desc) {
		List<Servicio> servicios = ServicioDAO.getInstancia().getServicios();
		ServicioDTO serv = new ServicioDTO();
		if (servicios != null && !servicios.isEmpty())
		{
			for (Servicio s : servicios)
				if(s.getDescripcion().equals(desc))
					serv = DTOTransformer.toServicioDTO(s);
		}
		return serv;
	}


	public void editarServicio(String nombre, String descripcion, boolean activo){

	}
	

	public boolean asociarServicios(Collection<Servicio> servicios, Proveedor proveedor){
		return false;
	}

	public List<ProveedorDTO> consultarProveedoresPorServicio(ServicioDTO servicioDTO)
	{
		List<ProveedorDTO> proveedoresDTO = new ArrayList<ProveedorDTO>();
		Collection<ProveedorDTO> proveedores = servicioDTO.getProveedores();
		if (proveedores != null && !proveedores.isEmpty())
		{
			for (ProveedorDTO prov : proveedores){
				proveedoresDTO.add(prov);
			}
		}
		return proveedoresDTO;
	}
	
	public List<ProveedorDTO> consultarProveedores()
	{
		List<ProveedorDTO> proveedoresDTO = null;
		List<ServicioDTO> servicios = consultarServicios();
		for (ServicioDTO serv : servicios){
			List<ProveedorDTO> proveedores = serv.getProveedores();
			if (proveedores != null && !proveedores.isEmpty())
			{
				proveedoresDTO = new ArrayList<ProveedorDTO>();
				for (ProveedorDTO prov : proveedores){
					proveedoresDTO.add(prov);
				}
			}
		}
		return proveedoresDTO;
	}
	
	public ProveedorDTO consultarProveedorPorDescripcion(String desc) {
		List<Proveedor> proveedores = ProveedorDAO.getInstancia().obtenerProveedores();
		ProveedorDTO prov = new ProveedorDTO();
		if (proveedores != null && !proveedores.isEmpty())
		{
			for (Proveedor p : proveedores)
				if(p.getRazonSocial().equals(desc))
					prov = DTOTransformer.toProveedorDTO(p);
		}
		return prov;
	}


	// Persona ------------------------------------------
	public boolean cargarPersonaFisica(String tipoDocumento, String telefono, String observaciones, String email, Integer documento, String direccion, String denominacion2, String denominacion1){
		return false;
	}



	// Empleado ------------------------------------------
	public void cargarEmpleado(Empleado empleado){
		empleados.add(empleado);
	}
	
	public Empleado buscarEmpleado(String legajo){
		Iterator<Empleado> it = empleados.iterator();
		Empleado emp = new Empleado();
		boolean encontrado = false;
		
		while(it.hasNext() && !encontrado)
		{
			if(it.next().getLegajo() == legajo){
				emp = it.next();
				encontrado = true;
			}
		}	
		return emp;
	}
	
	
	// TipoEvento ------------------------------------------
//	public void cargarTipoEventos(){
//		tipoEventos = TipoEventoDAO.getInstancia().getTipoEvento();
//	}
//	
	public Collection<TipoEventoDTO> consultarTipoEventos()
	{
		Collection<TipoEventoDTO> tipoEventosDTO = null;
		Collection<TipoEvento> tipoEventos = TipoEventoDAO.getInstancia().getTipoEvento(); 
		if (tipoEventos != null && !tipoEventos.isEmpty())
		{
			tipoEventosDTO = new ArrayList<TipoEventoDTO>();
			for (TipoEvento tipoEvento : tipoEventos){
				TipoEventoDTO tipoEventoDTO = DTOTransformer.toTipoEventoDTO(tipoEvento);
				tipoEventosDTO.add(tipoEventoDTO);
			}
		}
		
		return tipoEventosDTO;
	}
	
	//============== PRUEBAS =================
	
//	public void cargarColecciones(){
//		cargarTipoEventos();	
//	}



	
	
	
}